home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / idlelib / RemoteDebugger.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  14KB  |  400 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. """Support for remote Python debugging.
  5.  
  6. Some ASCII art to describe the structure:
  7.  
  8.        IN PYTHON SUBPROCESS          #             IN IDLE PROCESS
  9.                                      #
  10.                                      #        oid='gui_adapter'
  11.                  +----------+        #       +------------+          +-----+
  12.                  | GUIProxy |--remote#call-->| GUIAdapter |--calls-->| GUI |
  13. +-----+--calls-->+----------+        #       +------------+          +-----+
  14. | Idb |                               #                             /
  15. +-----+<-calls--+------------+         #      +----------+<--calls-/
  16.                 | IdbAdapter |<--remote#call--| IdbProxy |
  17.                 +------------+         #      +----------+
  18.                 oid='idb_adapter'      #
  19.  
  20. The purpose of the Proxy and Adapter classes is to translate certain
  21. arguments and return values that cannot be transported through the RPC
  22. barrier, in particular frame and traceback objects.
  23.  
  24. """
  25. import sys
  26. import types
  27. import rpc
  28. import Debugger
  29. debugging = 0
  30. idb_adap_oid = 'idb_adapter'
  31. gui_adap_oid = 'gui_adapter'
  32. frametable = { }
  33. dicttable = { }
  34. codetable = { }
  35. tracebacktable = { }
  36.  
  37. def wrap_frame(frame):
  38.     fid = id(frame)
  39.     frametable[fid] = frame
  40.     return fid
  41.  
  42.  
  43. def wrap_info(info):
  44.     '''replace info[2], a traceback instance, by its ID'''
  45.     if info is None:
  46.         return None
  47.     else:
  48.         traceback = info[2]
  49.         traceback_id = id(traceback)
  50.         tracebacktable[traceback_id] = traceback
  51.         modified_info = (info[0], info[1], traceback_id)
  52.         return modified_info
  53.  
  54.  
  55. class GUIProxy:
  56.     
  57.     def __init__(self, conn, gui_adap_oid):
  58.         self.conn = conn
  59.         self.oid = gui_adap_oid
  60.  
  61.     
  62.     def interaction(self, message, frame, info = None):
  63.         self.conn.remotecall(self.oid, 'interaction', (message, wrap_frame(frame), wrap_info(info)), { })
  64.  
  65.  
  66.  
  67. class IdbAdapter:
  68.     
  69.     def __init__(self, idb):
  70.         self.idb = idb
  71.  
  72.     
  73.     def set_step(self):
  74.         self.idb.set_step()
  75.  
  76.     
  77.     def set_quit(self):
  78.         self.idb.set_quit()
  79.  
  80.     
  81.     def set_continue(self):
  82.         self.idb.set_continue()
  83.  
  84.     
  85.     def set_next(self, fid):
  86.         frame = frametable[fid]
  87.         self.idb.set_next(frame)
  88.  
  89.     
  90.     def set_return(self, fid):
  91.         frame = frametable[fid]
  92.         self.idb.set_return(frame)
  93.  
  94.     
  95.     def get_stack(self, fid, tbid):
  96.         frame = frametable[fid]
  97.         if tbid is None:
  98.             tb = None
  99.         else:
  100.             tb = tracebacktable[tbid]
  101.         (stack, i) = self.idb.get_stack(frame, tb)
  102.         stack = [ (wrap_frame(frame), k) for frame, k in stack ]
  103.         return (stack, i)
  104.  
  105.     
  106.     def run(self, cmd):
  107.         import __main__ as __main__
  108.         self.idb.run(cmd, __main__.__dict__)
  109.  
  110.     
  111.     def set_break(self, filename, lineno):
  112.         msg = self.idb.set_break(filename, lineno)
  113.         return msg
  114.  
  115.     
  116.     def clear_break(self, filename, lineno):
  117.         msg = self.idb.clear_break(filename, lineno)
  118.         return msg
  119.  
  120.     
  121.     def clear_all_file_breaks(self, filename):
  122.         msg = self.idb.clear_all_file_breaks(filename)
  123.         return msg
  124.  
  125.     
  126.     def frame_attr(self, fid, name):
  127.         frame = frametable[fid]
  128.         return getattr(frame, name)
  129.  
  130.     
  131.     def frame_globals(self, fid):
  132.         frame = frametable[fid]
  133.         dict = frame.f_globals
  134.         did = id(dict)
  135.         dicttable[did] = dict
  136.         return did
  137.  
  138.     
  139.     def frame_locals(self, fid):
  140.         frame = frametable[fid]
  141.         dict = frame.f_locals
  142.         did = id(dict)
  143.         dicttable[did] = dict
  144.         return did
  145.  
  146.     
  147.     def frame_code(self, fid):
  148.         frame = frametable[fid]
  149.         code = frame.f_code
  150.         cid = id(code)
  151.         codetable[cid] = code
  152.         return cid
  153.  
  154.     
  155.     def code_name(self, cid):
  156.         code = codetable[cid]
  157.         return code.co_name
  158.  
  159.     
  160.     def code_filename(self, cid):
  161.         code = codetable[cid]
  162.         return code.co_filename
  163.  
  164.     
  165.     def dict_keys(self, did):
  166.         dict = dicttable[did]
  167.         return dict.keys()
  168.  
  169.     
  170.     def dict_item(self, did, key):
  171.         dict = dicttable[did]
  172.         value = dict[key]
  173.         value = repr(value)
  174.         return value
  175.  
  176.  
  177.  
  178. def start_debugger(rpchandler, gui_adap_oid):
  179.     '''Start the debugger and its RPC link in the Python subprocess
  180.  
  181.     Start the subprocess side of the split debugger and set up that side of the
  182.     RPC link by instantiating the GUIProxy, Idb debugger, and IdbAdapter
  183.     objects and linking them together.  Register the IdbAdapter with the
  184.     RPCServer to handle RPC requests from the split debugger GUI via the
  185.     IdbProxy.
  186.  
  187.     '''
  188.     gui_proxy = GUIProxy(rpchandler, gui_adap_oid)
  189.     idb = Debugger.Idb(gui_proxy)
  190.     idb_adap = IdbAdapter(idb)
  191.     rpchandler.register(idb_adap_oid, idb_adap)
  192.     return idb_adap_oid
  193.  
  194.  
  195. class FrameProxy:
  196.     
  197.     def __init__(self, conn, fid):
  198.         self._conn = conn
  199.         self._fid = fid
  200.         self._oid = 'idb_adapter'
  201.         self._dictcache = { }
  202.  
  203.     
  204.     def __getattr__(self, name):
  205.         if name[:1] == '_':
  206.             raise AttributeError, name
  207.         
  208.         if name == 'f_code':
  209.             return self._get_f_code()
  210.         
  211.         if name == 'f_globals':
  212.             return self._get_f_globals()
  213.         
  214.         if name == 'f_locals':
  215.             return self._get_f_locals()
  216.         
  217.         return self._conn.remotecall(self._oid, 'frame_attr', (self._fid, name), { })
  218.  
  219.     
  220.     def _get_f_code(self):
  221.         cid = self._conn.remotecall(self._oid, 'frame_code', (self._fid,), { })
  222.         return CodeProxy(self._conn, self._oid, cid)
  223.  
  224.     
  225.     def _get_f_globals(self):
  226.         did = self._conn.remotecall(self._oid, 'frame_globals', (self._fid,), { })
  227.         return self._get_dict_proxy(did)
  228.  
  229.     
  230.     def _get_f_locals(self):
  231.         did = self._conn.remotecall(self._oid, 'frame_locals', (self._fid,), { })
  232.         return self._get_dict_proxy(did)
  233.  
  234.     
  235.     def _get_dict_proxy(self, did):
  236.         if self._dictcache.has_key(did):
  237.             return self._dictcache[did]
  238.         
  239.         dp = DictProxy(self._conn, self._oid, did)
  240.         self._dictcache[did] = dp
  241.         return dp
  242.  
  243.  
  244.  
  245. class CodeProxy:
  246.     
  247.     def __init__(self, conn, oid, cid):
  248.         self._conn = conn
  249.         self._oid = oid
  250.         self._cid = cid
  251.  
  252.     
  253.     def __getattr__(self, name):
  254.         if name == 'co_name':
  255.             return self._conn.remotecall(self._oid, 'code_name', (self._cid,), { })
  256.         
  257.         if name == 'co_filename':
  258.             return self._conn.remotecall(self._oid, 'code_filename', (self._cid,), { })
  259.         
  260.  
  261.  
  262.  
  263. class DictProxy:
  264.     
  265.     def __init__(self, conn, oid, did):
  266.         self._conn = conn
  267.         self._oid = oid
  268.         self._did = did
  269.  
  270.     
  271.     def keys(self):
  272.         return self._conn.remotecall(self._oid, 'dict_keys', (self._did,), { })
  273.  
  274.     
  275.     def __getitem__(self, key):
  276.         return self._conn.remotecall(self._oid, 'dict_item', (self._did, key), { })
  277.  
  278.     
  279.     def __getattr__(self, name):
  280.         raise AttributeError, name
  281.  
  282.  
  283.  
  284. class GUIAdapter:
  285.     
  286.     def __init__(self, conn, gui):
  287.         self.conn = conn
  288.         self.gui = gui
  289.  
  290.     
  291.     def interaction(self, message, fid, modified_info):
  292.         frame = FrameProxy(self.conn, fid)
  293.         self.gui.interaction(message, frame, modified_info)
  294.  
  295.  
  296.  
  297. class IdbProxy:
  298.     
  299.     def __init__(self, conn, shell, oid):
  300.         self.oid = oid
  301.         self.conn = conn
  302.         self.shell = shell
  303.  
  304.     
  305.     def call(self, methodname, *args, **kwargs):
  306.         value = self.conn.remotecall(self.oid, methodname, args, kwargs)
  307.         return value
  308.  
  309.     
  310.     def run(self, cmd, locals):
  311.         seq = self.conn.asyncqueue(self.oid, 'run', (cmd,), { })
  312.         self.shell.interp.active_seq = seq
  313.  
  314.     
  315.     def get_stack(self, frame, tbid):
  316.         (stack, i) = self.call('get_stack', frame._fid, tbid)
  317.         stack = [ (FrameProxy(self.conn, fid), k) for fid, k in stack ]
  318.         return (stack, i)
  319.  
  320.     
  321.     def set_continue(self):
  322.         self.call('set_continue')
  323.  
  324.     
  325.     def set_step(self):
  326.         self.call('set_step')
  327.  
  328.     
  329.     def set_next(self, frame):
  330.         self.call('set_next', frame._fid)
  331.  
  332.     
  333.     def set_return(self, frame):
  334.         self.call('set_return', frame._fid)
  335.  
  336.     
  337.     def set_quit(self):
  338.         self.call('set_quit')
  339.  
  340.     
  341.     def set_break(self, filename, lineno):
  342.         msg = self.call('set_break', filename, lineno)
  343.         return msg
  344.  
  345.     
  346.     def clear_break(self, filename, lineno):
  347.         msg = self.call('clear_break', filename, lineno)
  348.         return msg
  349.  
  350.     
  351.     def clear_all_file_breaks(self, filename):
  352.         msg = self.call('clear_all_file_breaks', filename)
  353.         return msg
  354.  
  355.  
  356.  
  357. def start_remote_debugger(rpcclt, pyshell):
  358.     '''Start the subprocess debugger, initialize the debugger GUI and RPC link
  359.  
  360.     Request the RPCServer start the Python subprocess debugger and link.  Set
  361.     up the Idle side of the split debugger by instantiating the IdbProxy,
  362.     debugger GUI, and debugger GUIAdapter objects and linking them together.
  363.  
  364.     Register the GUIAdapter with the RPCClient to handle debugger GUI
  365.     interaction requests coming from the subprocess debugger via the GUIProxy.
  366.  
  367.     The IdbAdapter will pass execution and environment requests coming from the
  368.     Idle debugger GUI to the subprocess debugger via the IdbProxy.
  369.  
  370.     '''
  371.     global idb_adap_oid
  372.     idb_adap_oid = rpcclt.remotecall('exec', 'start_the_debugger', (gui_adap_oid,), { })
  373.     idb_proxy = IdbProxy(rpcclt, pyshell, idb_adap_oid)
  374.     gui = Debugger.Debugger(pyshell, idb_proxy)
  375.     gui_adap = GUIAdapter(rpcclt, gui)
  376.     rpcclt.register(gui_adap_oid, gui_adap)
  377.     return gui
  378.  
  379.  
  380. def close_remote_debugger(rpcclt):
  381.     '''Shut down subprocess debugger and Idle side of debugger RPC link
  382.  
  383.     Request that the RPCServer shut down the subprocess debugger and link.
  384.     Unregister the GUIAdapter, which will cause a GC on the Idle process
  385.     debugger and RPC link objects.  (The second reference to the debugger GUI
  386.     is deleted in PyShell.close_remote_debugger().)
  387.  
  388.     '''
  389.     close_subprocess_debugger(rpcclt)
  390.     rpcclt.unregister(gui_adap_oid)
  391.  
  392.  
  393. def close_subprocess_debugger(rpcclt):
  394.     rpcclt.remotecall('exec', 'stop_the_debugger', (idb_adap_oid,), { })
  395.  
  396.  
  397. def restart_subprocess_debugger(rpcclt):
  398.     idb_adap_oid_ret = rpcclt.remotecall('exec', 'start_the_debugger', (gui_adap_oid,), { })
  399.  
  400.